home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 1 / Cream of the Crop 1.iso / PROGRAM / DDJ0992.ARJ / DIALBOX.C < prev    next >
Text File  |  1992-08-11  |  22KB  |  746 lines
  1. /* ----------------- dialbox.c -------------- */
  2.  
  3. #include "dflat.h"
  4.  
  5. static int inFocusCommand(DBOX *);
  6. static void dbShortcutKeys(DBOX *, int);
  7. static int ControlProc(WINDOW, MESSAGE, PARAM, PARAM);
  8. static void FirstFocus(DBOX *db);
  9. static void NextFocus(DBOX *db);
  10. static void PrevFocus(DBOX *db);
  11. static CTLWINDOW *AssociatedControl(DBOX *, enum commands);
  12.  
  13. static BOOL SysMenuOpen;
  14.  
  15. static DBOX **dbs = NULL;
  16. static int dbct = 0;
  17.  
  18. /* --- clear all heap allocations to control text fields --- */
  19. void ClearDialogBoxes(void)
  20. {
  21.     int i;
  22.     for (i = 0; i < dbct; i++)    {
  23.         CTLWINDOW *ct = (*(dbs+i))->ctl;
  24.         while (ct->class)    {
  25.             if ((ct->class == EDITBOX ||
  26.                     ct->class == COMBOBOX) &&
  27.                     ct->itext != NULL)
  28.                 free(ct->itext);
  29.             ct++;
  30.         }
  31.     }
  32.     if (dbs != NULL)    {
  33.         free(dbs);
  34.         dbs = NULL;
  35.     }
  36.     dbct = 0;
  37. }
  38.  
  39. /* -------- CREATE_WINDOW Message --------- */
  40. static int CreateWindowMsg(WINDOW wnd, PARAM p1, PARAM p2)
  41. {
  42.     DBOX *db = wnd->extension;
  43.     CTLWINDOW *ct = db->ctl;
  44.     WINDOW cwnd;
  45.     int rtn, i;
  46.     /* ---- build a table of processed dialog boxes ---- */
  47.     for (i = 0; i < dbct; i++)
  48.         if (db == dbs[i])
  49.             break;
  50.     if (i == dbct)    {
  51.         dbs = DFrealloc(dbs, sizeof(DBOX *) * (dbct+1));
  52.         *(dbs + dbct++) = db;
  53.     }
  54.     rtn = BaseWndProc(DIALOG, wnd, CREATE_WINDOW, p1, p2);
  55.     ct = db->ctl;
  56.     while (ct->class)    {
  57.         int attrib = 0;
  58.         if (TestAttribute(wnd, NOCLIP))
  59.             attrib |= NOCLIP;
  60.         if (wnd->Modal)
  61.             attrib |= SAVESELF;
  62.         ct->setting = ct->isetting;
  63.         if (ct->class == EDITBOX && ct->dwnd.h > 1)
  64.             attrib |= (MULTILINE | HASBORDER);
  65.         else if ((ct->class == LISTBOX || ct->class == TEXTBOX) &&
  66.                 ct->dwnd.h > 2)
  67.             attrib |= HASBORDER;
  68.         cwnd = CreateWindow(ct->class,
  69.                         ct->dwnd.title,
  70.                         ct->dwnd.x+GetClientLeft(wnd),
  71.                         ct->dwnd.y+GetClientTop(wnd),
  72.                         ct->dwnd.h,
  73.                         ct->dwnd.w,
  74.                         ct,
  75.                         wnd,
  76.                         ControlProc,
  77.                         attrib);
  78.         if ((ct->class == EDITBOX ||
  79.                 ct->class == COMBOBOX) &&
  80.                     ct->itext != NULL)
  81.             SendMessage(cwnd, SETTEXT, (PARAM) ct->itext, 0);
  82.         ct++;
  83.     }
  84.     return rtn;
  85. }
  86.  
  87. /* -------- LEFT_BUTTON Message --------- */
  88. static BOOL LeftButtonMsg(WINDOW wnd, PARAM p1, PARAM p2)
  89. {
  90.     DBOX *db = wnd->extension;
  91.     CTLWINDOW *ct = db->ctl;
  92.     if (WindowSizing || WindowMoving)
  93.         return TRUE;
  94.     if (HitControlBox(wnd, p1-GetLeft(wnd), p2-GetTop(wnd))) {
  95.         PostMessage(wnd, KEYBOARD, ' ', ALTKEY);
  96.         return TRUE;
  97.     }
  98.     while (ct->class)    {
  99.         WINDOW cwnd = ct->wnd;
  100.         if (ct->class == COMBOBOX)    {
  101.             if (p2 == GetTop(cwnd))    {
  102.                 if (p1 == GetRight(cwnd)+1)    {
  103.                     SendMessage(cwnd, LEFT_BUTTON, p1, p2);
  104.                     return TRUE;
  105.                 }
  106.             }
  107.             if (GetClass(inFocus) == LISTBOX)
  108.                 SendMessage(wnd, SETFOCUS, TRUE, 0);
  109.         }
  110.         else if (ct->class == SPINBUTTON)    {
  111.             if (p2 == GetTop(cwnd))    {
  112.                 if (p1 == GetRight(cwnd)+1 ||
  113.                         p1 == GetRight(cwnd)+2)    {
  114.                     SendMessage(cwnd, LEFT_BUTTON, p1, p2);
  115.                     return TRUE;
  116.                 }
  117.             }
  118.         }
  119.         ct++;
  120.     }
  121.     return FALSE;
  122. }
  123.  
  124. /* -------- KEYBOARD Message --------- */
  125. static BOOL KeyboardMsg(WINDOW wnd, PARAM p1, PARAM p2)
  126. {
  127.     DBOX *db = wnd->extension;
  128.     CTLWINDOW *ct;
  129.  
  130.     if (WindowMoving || WindowSizing)
  131.         return FALSE;
  132.     switch ((int)p1)    {
  133.         case F1:
  134.             ct = GetControl(inFocus);
  135.             if (ct != NULL)
  136.                 if (DisplayHelp(wnd, ct->help))
  137.                     return TRUE;
  138.             break;
  139.         case SHIFT_HT:
  140.         case BS:
  141.         case UP:
  142.             PrevFocus(db);
  143.             break;
  144.         case ALT_F6:
  145.         case '\t':
  146.         case FWD:
  147.         case DN:
  148.             NextFocus(db);
  149.             break;
  150.         case ' ':
  151.             if (((int)p2 & ALTKEY) &&
  152.                     TestAttribute(wnd, CONTROLBOX))    {
  153.                 SysMenuOpen = TRUE;
  154.                 BuildSystemMenu(wnd);
  155.             }
  156.             break;
  157.         case CTRL_F4:
  158.         case ESC:
  159.             SendMessage(wnd, COMMAND, ID_CANCEL, 0);
  160.             break;
  161.         default:
  162.             /* ------ search all the shortcut keys ----- */
  163.             dbShortcutKeys(db, (int) p1);
  164.             break;
  165.     }
  166.     return wnd->Modal;
  167. }
  168.  
  169. /* -------- COMMAND Message --------- */
  170. static BOOL CommandMsg(WINDOW wnd, PARAM p1, PARAM p2)
  171. {
  172.     DBOX *db = wnd->extension;
  173.     switch ((int) p1)    {
  174.         case ID_OK:
  175.         case ID_CANCEL:
  176.             if ((int)p2 != 0)
  177.                 return TRUE;
  178.             wnd->ReturnCode = (int) p1;
  179.             if (wnd->Modal)
  180.                 PostMessage(wnd, ENDDIALOG, 0, 0);
  181.             else
  182.                 SendMessage(wnd, CLOSE_WINDOW, TRUE, 0);
  183.             return TRUE;
  184.         case ID_HELP:
  185.             if ((int)p2 != 0)
  186.                 return TRUE;
  187.             return DisplayHelp(wnd, db->HelpName);
  188.         default:
  189.             break;
  190.     }
  191.     return FALSE;
  192. }
  193.  
  194. /* ----- window-processing module, DIALOG window class ----- */
  195. int DialogProc(WINDOW wnd, MESSAGE msg, PARAM p1, PARAM p2)
  196. {
  197.     DBOX *db = wnd->extension;
  198.  
  199.     switch (msg)    {
  200.         case CREATE_WINDOW:
  201.             return CreateWindowMsg(wnd, p1, p2);
  202.         case SHIFT_CHANGED:
  203.             if (wnd->Modal)
  204.                 return TRUE;
  205.             break;
  206.         case LEFT_BUTTON:
  207.             if (LeftButtonMsg(wnd, p1, p2))
  208.                 return TRUE;
  209.             break;
  210.         case KEYBOARD:
  211.             if (KeyboardMsg(wnd, p1, p2))
  212.                 return TRUE;
  213.             break;
  214.         case CLOSE_POPDOWN:
  215.             SysMenuOpen = FALSE;
  216.             break;
  217.         case LB_SELECTION:
  218.         case LB_CHOOSE:
  219.             if (SysMenuOpen)
  220.                 return TRUE;
  221.             SendMessage(wnd, COMMAND, inFocusCommand(db), msg);
  222.             break;
  223.         case COMMAND:
  224.             if (CommandMsg(wnd, p1, p2))
  225.                 return TRUE;
  226.             break;
  227.         case PAINT:
  228.             p2 = TRUE;
  229.             break;
  230.         case CLOSE_WINDOW:
  231.             if (!p1)    {
  232.                 SendMessage(wnd, COMMAND, ID_CANCEL, 0);
  233.                 return TRUE;
  234.             }
  235.             break;
  236.         default:
  237.             break;
  238.     }
  239.     return BaseWndProc(DIALOG, wnd, msg, p1, p2);
  240. }
  241.  
  242. /* ------- create and execute a dialog box ---------- */
  243. BOOL DialogBox(WINDOW wnd, DBOX *db, BOOL Modal,
  244.   int (*wndproc)(struct window *, enum messages, PARAM, PARAM))
  245. {
  246.     BOOL rtn;
  247.     int x = db->dwnd.x, y = db->dwnd.y;
  248.     WINDOW DialogWnd;
  249.  
  250.     if (!Modal && wnd != NULL)    {
  251.         x += GetLeft(wnd);
  252.         y += GetTop(wnd);
  253.     }
  254.     DialogWnd = CreateWindow(DIALOG,
  255.                         db->dwnd.title,
  256.                         x, y,
  257.                         db->dwnd.h,
  258.                         db->dwnd.w,
  259.                         db,
  260.                         wnd,
  261.                         wndproc,
  262.                         Modal ? SAVESELF : 0);
  263.     DialogWnd->Modal = Modal;
  264.     FirstFocus(db);
  265.     PostMessage(DialogWnd, INITIATE_DIALOG, 0, 0);
  266.     if (Modal)    {
  267.         SendMessage(DialogWnd, CAPTURE_MOUSE, 0, 0);
  268.         SendMessage(DialogWnd, CAPTURE_KEYBOARD, 0, 0);
  269.         while (dispatch_message())
  270.             ;
  271.         rtn = DialogWnd->ReturnCode == ID_OK;
  272.         SendMessage(DialogWnd, RELEASE_MOUSE, 0, 0);
  273.         SendMessage(DialogWnd, RELEASE_KEYBOARD, 0, 0);
  274.         SendMessage(DialogWnd, CLOSE_WINDOW, TRUE, 0);
  275.         return rtn;
  276.     }
  277.     return FALSE;
  278. }
  279.  
  280. /* ----- return command code of in-focus control window ---- */
  281. static int inFocusCommand(DBOX *db)
  282. {
  283.     CTLWINDOW *ct = db->ctl;
  284.     while (ct->class)    {
  285.         if (ct->wnd == inFocus)
  286.             return ct->command;
  287.         ct++;
  288.     }
  289.     return -1;
  290. }
  291.  
  292. /* -------- find a specified control structure ------- */
  293. CTLWINDOW *FindCommand(DBOX *db, enum commands cmd, int class)
  294. {
  295.     CTLWINDOW *ct = db->ctl;
  296.     while (ct->class)    {
  297.         if (ct->class == class)
  298.             if (cmd == ct->command)
  299.                 return ct;
  300.         ct++;
  301.     }
  302.     return NULL;
  303. }
  304.  
  305. /* ---- return the window handle of a specified command ---- */
  306. WINDOW ControlWindow(DBOX *db, enum commands cmd)
  307. {
  308.     CTLWINDOW *ct = db->ctl;
  309.     while (ct->class)    {
  310.         if (ct->class != TEXT && cmd == ct->command)
  311.             return ct->wnd;
  312.         ct++;
  313.     }
  314.     return NULL;
  315. }
  316.  
  317. /* --- return a pointer to the control structure that matches a window --- */
  318. CTLWINDOW *WindowControl(DBOX *db, WINDOW wnd)
  319. {
  320.     CTLWINDOW *ct = db->ctl;
  321.     while (ct->class)    {
  322.         if (ct->wnd == wnd)
  323.             return ct;
  324.         ct++;
  325.     }
  326.     return NULL;
  327. }
  328.  
  329. /* ---- set a control ON or OFF ----- */
  330. void ControlSetting(DBOX *db, enum commands cmd,
  331.                                 int class, int setting)
  332. {
  333.     CTLWINDOW *ct = FindCommand(db, cmd, class);
  334.     if (ct != NULL)    {
  335.         ct->isetting = setting;
  336.         if (ct->wnd != NULL)
  337.             ct->setting = setting;
  338.     }
  339. }
  340.  
  341. /* ---- return pointer to the text of a control window ---- */
  342. char *GetDlgTextString(DBOX *db,enum commands cmd,CLASS class)
  343. {
  344.     CTLWINDOW *ct = FindCommand(db, cmd, class);
  345.     if (ct != NULL)
  346.         return ct->itext;
  347.     else
  348.         return NULL;
  349. }
  350.  
  351. /* ------- set the text of a control specification ------ */
  352. void SetDlgTextString(DBOX *db, enum commands cmd,
  353.                                     char *text, CLASS class)
  354. {
  355.     CTLWINDOW *ct = FindCommand(db, cmd, class);
  356.     if (ct != NULL)    {
  357.         ct->itext = DFrealloc(ct->itext, strlen(text)+1);
  358.         strcpy(ct->itext, text);
  359.     }
  360. }
  361.  
  362. /* ------- set the text of a control window ------ */
  363. void PutItemText(WINDOW wnd, enum commands cmd, char *text)
  364. {
  365.     CTLWINDOW *ct = FindCommand(wnd->extension, cmd, EDITBOX);
  366.  
  367.     if (ct == NULL)
  368.         ct = FindCommand(wnd->extension, cmd, TEXTBOX);
  369.     if (ct == NULL)
  370.         ct = FindCommand(wnd->extension, cmd, COMBOBOX);
  371.     if (ct == NULL)
  372.         ct = FindCommand(wnd->extension, cmd, LISTBOX);
  373.     if (ct == NULL)
  374.         ct = FindCommand(wnd->extension, cmd, SPINBUTTON);
  375.     if (ct == NULL)
  376.         ct = FindCommand(wnd->extension, cmd, TEXT);
  377.     if (ct != NULL)        {
  378.         WINDOW cwnd = (WINDOW) (ct->wnd);
  379.         switch (ct->class)    {
  380.             case COMBOBOX:
  381.             case EDITBOX:
  382.                 SendMessage(cwnd, CLEARTEXT, 0, 0);
  383.                 SendMessage(cwnd, ADDTEXT, (PARAM) text, 0);
  384.                 if (!isMultiLine(cwnd))
  385.                     SendMessage(cwnd, PAINT, 0, 0);
  386.                 break;
  387.             case LISTBOX:
  388.             case TEXTBOX:
  389.             case SPINBUTTON:
  390.                 SendMessage(cwnd, ADDTEXT, (PARAM) text, 0);
  391.                 break;
  392.             case TEXT:    {
  393.                 SendMessage(cwnd, CLEARTEXT, 0, 0);
  394.                 SendMessage(cwnd, ADDTEXT, (PARAM) text, 0);
  395.                 SendMessage(cwnd, PAINT, 0, 0);
  396.                 break;
  397.             }
  398.             default:
  399.                 break;
  400.         }
  401.     }
  402. }
  403.  
  404. /* ------- get the text of a control window ------ */
  405. void GetItemText(WINDOW wnd, enum commands cmd,
  406.                                 char *text, int len)
  407. {
  408.     CTLWINDOW *ct = FindCommand(wnd->extension, cmd, EDITBOX);
  409.     unsigned char *cp;
  410.  
  411.     if (ct == NULL)
  412.         ct = FindCommand(wnd->extension, cmd, COMBOBOX);
  413.     if (ct == NULL)
  414.         ct = FindCommand(wnd->extension, cmd, TEXTBOX);
  415.     if (ct == NULL)
  416.         ct = FindCommand(wnd->extension, cmd, TEXT);
  417.     if (ct != NULL)    {
  418.         WINDOW cwnd = (WINDOW) (ct->wnd);
  419.         if (cwnd != NULL)    {
  420.             switch (ct->class)    {
  421.                 case TEXT:
  422.                     if (GetText(cwnd) != NULL)    {
  423.                         cp = strchr(GetText(cwnd), '\n');
  424.                         if (cp != NULL)
  425.                             len = (int) (cp - GetText(cwnd));
  426.                         strncpy(text, GetText(cwnd), len);
  427.                         *(text+len) = '\0';
  428.                     }
  429.                     break;
  430.                 case TEXTBOX:
  431.                     if (GetText(cwnd) != NULL)
  432.                         strncpy(text, GetText(cwnd), len);
  433.                     break;
  434.                 case COMBOBOX:
  435.                 case EDITBOX:
  436.                     SendMessage(cwnd,GETTEXT,(PARAM)text,len);
  437.                     break;
  438.                 default:
  439.                     break;
  440.             }
  441.         }
  442.     }
  443. }
  444.  
  445. /* ------- set the text of a listbox control window ------ */
  446. void GetDlgListText(WINDOW wnd, char *text, enum commands cmd)
  447. {
  448.     CTLWINDOW *ct = FindCommand(wnd->extension, cmd, LISTBOX);
  449.     int sel = SendMessage(ct->wnd, LB_CURRENTSELECTION, 0, 0);
  450.     SendMessage(ct->wnd, LB_GETTEXT, (PARAM) text, sel);
  451. }
  452.  
  453. /* -- find control structure associated with text control -- */
  454. static CTLWINDOW *AssociatedControl(DBOX *db,enum commands Tcmd)
  455. {
  456.     CTLWINDOW *ct = db->ctl;
  457.     while (ct->class)    {
  458.         if (ct->class != TEXT)
  459.             if (ct->command == Tcmd)
  460.                 break;
  461.         ct++;
  462.     }
  463.     return ct;
  464. }
  465.  
  466. /* --- process dialog box shortcut keys --- */
  467. static void dbShortcutKeys(DBOX *db, int ky)
  468. {
  469.     CTLWINDOW *ct;
  470.     int ch = AltConvert(ky);
  471.  
  472.     if (ch != 0)    {
  473.         ct = db->ctl;
  474.         while (ct->class)    {
  475.             char *cp = ct->itext;
  476.             while (cp && *cp)    {
  477.                 if (*cp == SHORTCUTCHAR &&
  478.                             tolower(*(cp+1)) == ch)    {
  479.                     if (ct->class == TEXT)
  480.                         ct = AssociatedControl(db, ct->command);
  481.                     if (ct->class == RADIOBUTTON)
  482.                         SetRadioButton(db, ct);
  483.                     else if (ct->class == CHECKBOX)    {
  484.                         ct->setting ^= ON;
  485.                         SendMessage(ct->wnd, PAINT, 0, 0);
  486.                     }
  487.                     else if (ct->class)    {
  488.                         SendMessage(ct->wnd, SETFOCUS, TRUE, 0);
  489.                         if (ct->class == BUTTON)
  490.                            SendMessage(ct->wnd,KEYBOARD,'\r',0);
  491.                     }
  492.                     return;
  493.                 }
  494.                 cp++;
  495.             }
  496.             ct++;
  497.         }
  498.     }
  499. }
  500.  
  501. /* --- dynamically add or remove scroll bars
  502.                             from a control window ---- */
  503. void SetScrollBars(WINDOW wnd)
  504. {
  505.     int oldattr = GetAttribute(wnd);
  506.     if (wnd->wlines > ClientHeight(wnd))
  507.         AddAttribute(wnd, VSCROLLBAR);
  508.     else 
  509.         ClearAttribute(wnd, VSCROLLBAR);
  510.     if (wnd->textwidth > ClientWidth(wnd))
  511.         AddAttribute(wnd, HSCROLLBAR);
  512.     else 
  513.         ClearAttribute(wnd, HSCROLLBAR);
  514.     if (GetAttribute(wnd) != oldattr)
  515.         SendMessage(wnd, BORDER, 0, 0);
  516. }
  517.  
  518. /* ------- CREATE_WINDOW Message (Control) ----- */
  519. static void CtlCreateWindowMsg(WINDOW wnd)
  520. {
  521.     CTLWINDOW *ct;
  522.     ct = wnd->ct = wnd->extension;
  523.     wnd->extension = NULL;
  524.     if (ct != NULL)
  525.         ct->wnd = wnd;
  526. }
  527.  
  528. /* ------- KEYBOARD Message (Control) ----- */
  529. static BOOL CtlKeyboardMsg(WINDOW wnd, PARAM p1, PARAM p2)
  530. {
  531.     CTLWINDOW *ct = GetControl(wnd);
  532.     switch ((int) p1)    {
  533.         case F1:
  534.             if (WindowMoving || WindowSizing)
  535.                 break;
  536.             if (!DisplayHelp(wnd, ct->help))
  537.                 SendMessage(GetParent(wnd),COMMAND,ID_HELP,0);
  538.             return TRUE;
  539.         case ' ':
  540.             if (!((int)p2 & ALTKEY))
  541.                 break;
  542.         case ALT_F6:
  543.         case CTRL_F4:
  544.         case ALT_F4:
  545.             PostMessage(GetParent(wnd), KEYBOARD, p1, p2);
  546.             return TRUE;
  547.         default:
  548.             break;
  549.     }
  550.     if (GetClass(wnd) == EDITBOX)
  551.         if (isMultiLine(wnd))
  552.             return FALSE;
  553.     switch ((int) p1)    {
  554.         case UP:
  555.             if (!isDerivedFrom(wnd, LISTBOX))    {
  556.                 p1 = CTRL_FIVE;
  557.                 p2 = LEFTSHIFT;
  558.             }
  559.             break;
  560.         case BS:
  561.             if (!isDerivedFrom(wnd, EDITBOX))    {
  562.                 p1 = CTRL_FIVE;
  563.                 p2 = LEFTSHIFT;
  564.             }
  565.             break;
  566.         case DN:
  567.             if (!isDerivedFrom(wnd, LISTBOX) &&
  568.                     !isDerivedFrom(wnd, COMBOBOX))
  569.                 p1 = '\t';
  570.             break;
  571.         case FWD:
  572.             if (!isDerivedFrom(wnd, EDITBOX))
  573.                 p1 = '\t';
  574.             break;
  575.         case '\r':
  576.             if (isDerivedFrom(wnd, EDITBOX))
  577.                 if (isMultiLine(wnd))
  578.                     break;
  579.             if (isDerivedFrom(wnd, BUTTON))
  580.                 break;
  581.             SendMessage(GetParent(wnd), COMMAND, ID_OK, 0);
  582.             return TRUE;
  583.         default:
  584.             break;
  585.     }
  586.     return FALSE;
  587. }
  588.  
  589. /* ------- CLOSE_WINDOW Message (Control) ----- */
  590. static void CtlCloseWindowMsg(WINDOW wnd)
  591. {
  592.     CTLWINDOW *ct = GetControl(wnd);
  593.     if (ct != NULL)    {
  594.         ct->wnd = NULL;
  595.         if (GetParent(wnd)->ReturnCode == ID_OK)    {
  596.             if (ct->class == EDITBOX || ct->class == COMBOBOX)    {
  597.                 if (wnd->TextChanged)    {
  598.                     ct->itext=DFrealloc(ct->itext,strlen(wnd->text)+1);
  599.                     strcpy(ct->itext, wnd->text);
  600.                     if (!isMultiLine(wnd))    {
  601.                         char *cp = ct->itext+strlen(ct->itext)-1;
  602.                         if (*cp == '\n')
  603.                             *cp = '\0';
  604.                     }
  605.                 }
  606.             }
  607.             else if (ct->class == RADIOBUTTON || ct->class == CHECKBOX)
  608.                 ct->isetting = ct->setting;
  609.         }
  610.     }
  611. }
  612.  
  613. static void FixColors(WINDOW wnd)
  614. {
  615.     CTLWINDOW *ct = wnd->ct;
  616.     if (ct->class != BUTTON)    {
  617.         if (ct->class != SPINBUTTON && ct->class != COMBOBOX)    {
  618.             wnd->WindowColors[FRAME_COLOR][FG] = 
  619.                 GetParent(wnd)->WindowColors[FRAME_COLOR][FG];
  620.             wnd->WindowColors[FRAME_COLOR][BG] = 
  621.                 GetParent(wnd)->WindowColors[FRAME_COLOR][BG];
  622.             if (ct->class != EDITBOX && ct->class != LISTBOX)    {
  623.                 wnd->WindowColors[STD_COLOR][FG] = 
  624.                     GetParent(wnd)->WindowColors[STD_COLOR][FG];
  625.                 wnd->WindowColors[STD_COLOR][BG] = 
  626.                     GetParent(wnd)->WindowColors[STD_COLOR][BG];
  627.             }
  628.         }
  629.     }
  630. }
  631.  
  632. /* -- generic window processor used by dialog box controls -- */
  633. static int ControlProc(WINDOW wnd,MESSAGE msg,PARAM p1,PARAM p2)
  634. {
  635.     DBOX *db;
  636.  
  637.     if (wnd == NULL)
  638.         return FALSE;
  639.     db = GetParent(wnd) ? GetParent(wnd)->extension : NULL;
  640.  
  641.     switch (msg)    {
  642.         case CREATE_WINDOW:
  643.             CtlCreateWindowMsg(wnd);
  644.             break;
  645.         case KEYBOARD:
  646.             if (CtlKeyboardMsg(wnd, p1, p2))
  647.                 return TRUE;
  648.             break;
  649.         case PAINT:
  650.             FixColors(wnd);
  651.             if (GetClass(wnd) == EDITBOX ||
  652.                     GetClass(wnd) == LISTBOX ||
  653.                         GetClass(wnd) == TEXTBOX)
  654.                 SetScrollBars(wnd);
  655.             break;
  656.         case BORDER:
  657.             FixColors(wnd);
  658.             if (GetClass(wnd) == EDITBOX)    {
  659.                 WINDOW oldFocus = inFocus;
  660.                 inFocus = NULL;
  661.                 DefaultWndProc(wnd, msg, p1, p2);
  662.                 inFocus = oldFocus;
  663.                 return TRUE;
  664.             }
  665.             break;
  666.         case SETFOCUS:
  667.             if (p1)    {
  668.                 DefaultWndProc(wnd, msg, p1, p2);
  669.                 SendMessage(GetParent(wnd), COMMAND,
  670.                     inFocusCommand(db), ENTERFOCUS);
  671.                 return TRUE;
  672.             }
  673.             else 
  674.                 SendMessage(GetParent(wnd), COMMAND,
  675.                     inFocusCommand(db), LEAVEFOCUS);
  676.             break;
  677.         case CLOSE_WINDOW:
  678.             CtlCloseWindowMsg(wnd);
  679.             break;
  680.         default:
  681.             break;
  682.     }
  683.     return DefaultWndProc(wnd, msg, p1, p2);
  684. }
  685.  
  686. /* ---- change the focus to the first control --- */
  687. static void FirstFocus(DBOX *db)
  688. {
  689.     CTLWINDOW *ct = db->ctl;
  690.     if (ct != NULL)    {
  691.         while (ct->class == TEXT || ct->class == BOX)    {
  692.             ct++;
  693.             if (ct->class == 0)
  694.                 return;
  695.         }
  696.         SendMessage(ct->wnd, SETFOCUS, TRUE, 0);
  697.     }
  698. }
  699.  
  700. /* ---- change the focus to the next control --- */
  701. static void NextFocus(DBOX *db)
  702. {
  703.     CTLWINDOW *ct = WindowControl(db, inFocus);
  704.     int looped = 0;
  705.     if (ct != NULL)    {
  706.         do    {
  707.             ct++;
  708.             if (ct->class == 0)    {
  709.                 if (looped)
  710.                     return;
  711.                 looped++;
  712.                 ct = db->ctl;
  713.             }
  714.         } while (ct->class == TEXT || ct->class == BOX);
  715.         SendMessage(ct->wnd, SETFOCUS, TRUE, 0);
  716.     }
  717. }
  718.  
  719. /* ---- change the focus to the previous control --- */
  720. static void PrevFocus(DBOX *db)
  721. {
  722.     CTLWINDOW *ct = WindowControl(db, inFocus);
  723.     int looped = 0;
  724.     if (ct != NULL)    {
  725.         do    {
  726.             if (ct == db->ctl)    {
  727.                 if (looped)
  728.                     return;
  729.                 looped++;
  730.                 while (ct->class)
  731.                     ct++;
  732.             }
  733.             --ct;
  734.         } while (ct->class == TEXT || ct->class == BOX);
  735.         SendMessage(ct->wnd, SETFOCUS, TRUE, 0);
  736.     }
  737. }
  738.  
  739. void SetFocusCursor(WINDOW wnd)
  740. {
  741.     if (wnd == inFocus)    {
  742.         SendMessage(NULL, SHOW_CURSOR, 0, 0);
  743.         SendMessage(wnd, KEYBOARD_CURSOR, 1, 0);
  744.     }
  745. }
  746.